package cn.wl.hrm.service.impl;

import cn.wl.hrm.constant.Constant;
import cn.wl.hrm.domain.CourseType;
import cn.wl.hrm.feign.client.RedisFeignClient;
import cn.wl.hrm.mapper.CourseTypeMapper;
import cn.wl.hrm.service.ICourseTypeService;
import cn.wl.hrm.util.AjaxResult;
import cn.wl.hrm.vo.CourseTypeVo;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author wl
 * @since 2020-04-18
 */
@Service
@Transactional
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private RedisFeignClient redisFeignClient;

    //从缓存中查询数据
    public List<CourseType> selectFromRedis(){
        //从缓存中查询key为key_coursetype的值，得到ajaxResult
        AjaxResult ajaxResult = redisFeignClient.get(Constant.REDIS_KEY_COURSETYPE);
        //判断ajaxResult是否操作成功并且ajaxResult.getResultObj()是否有值
        if(ajaxResult.isSuccess() && ajaxResult.getResultObj() != null){
            //通过ajaxResult获取到值并转换为json字符串
            String result = ajaxResult.getResultObj().toString();
            //将json字符串转换为集合
            List<CourseType> courseTypes = JSON.parseArray(result, CourseType.class);
            //返回课程分类数据
            return courseTypes;
        }
        //缓存中没有数据
        //在数据库中去查询得到数据
        //将数据库中查询到的数据转换成json字符串的格式存到缓存中
        List<CourseType> courseTypes = courseTypesToRedisFromMysql();

        //返回课程分类数据
        return courseTypes;
    }
    
    //抽取方法：增删改后，重置缓存
    private List<CourseType> courseTypesToRedisFromMysql() {
        //在数据库中去查询得到数据
        List<CourseType> courseTypes = baseMapper.selectList(null);
        //将数据库中查询到的数据转换成json字符串的格式存到缓存中
        redisFeignClient.set(Constant.REDIS_KEY_COURSETYPE, JSON.toJSONString(courseTypes));
        return courseTypes;
    }


    @Override
    public List<CourseType> treeData() {
        //获取所有课程类型
        List<CourseType> allCourseTypes = selectFromRedis();
        //创建一个集合用来装一级分类
        List<CourseType> parentCourseTypeList = new ArrayList();
        //遍历所有的课程类型
        for (CourseType currentCourseType : allCourseTypes) {
            //判断课程类型的pid是否为0
            if(currentCourseType.getPid() == 0){
                //pid为0，将其添加到一级分类中
                parentCourseTypeList.add(currentCourseType);
            }else {
                //这里的currentCourseType为二级及以上的分类
                //遍历所有的课程类型
                for (CourseType parentCourseType : allCourseTypes) {
                    //判断currentCourseType的pid是否等于parentCourseType的id
                    if(currentCourseType.getPid().equals(parentCourseType.getId())){
                        //如果两者相等，就将判断currentCourseType添加到parentCourseType的children里面
                        parentCourseType.getChildren().add(currentCourseType);
                        break;
                    }
                }
            }
        }
        return parentCourseTypeList;
    }


    @Override
    public boolean insert(CourseType entity) {
        boolean result = super.insert(entity);
        if(result){
            //添加之后，查询出所有的课程分类
            //将数据库中查询到的数据转换成json字符串的格式存到缓存中
            List<CourseType> courseTypes = courseTypesToRedisFromMysql();
        }
        return result;
    }
    @Override
    public boolean deleteById(Serializable id) {
        boolean result = super.deleteById(id);
        if(result){
            //添加之后，查询出所有的课程分类
            //将数据库中查询到的数据转换成json字符串的格式存到缓存中
            List<CourseType> courseTypes = courseTypesToRedisFromMysql();
        }
        return result;
    }

    @Override
    public boolean updateById(CourseType entity) {
        boolean result = super.updateById(entity);
        if(result){
            //添加之后，查询出所有的课程分类
            //将数据库中查询到的数据转换成json字符串的格式存到缓存中
            List<CourseType> courseTypes = courseTypesToRedisFromMysql();
        }
        return result;
    }

    //面包屑查询
    @Override
    public List<CourseTypeVo> crumbs(Long courseTypeId) {
        System.out.println(courseTypeId);
        //根据id获取到当前类型
        CourseType courseType = baseMapper.selectById(courseTypeId);
        //再从当前类型中拿到path--所有的父级id
        String path = courseType.getPath();
        //将path分割拿到paths数组--父级id数组
        String[] paths = path.split("\\.");
        //将paths数组转换成Long类型
        List<Long> ids = new ArrayList<>();
        for (String s : paths) {
            ids.add(Long.valueOf(s));
        }
        //根据ids批量查询课程类型
        List<CourseType> CourseTypes = baseMapper.selectBatchIds(ids);
        //创建一个list集合，用来装面包屑需要展示的所有课程类型，最终返回以下格式
        /*
        [
            {
                own:{id:"1",name:"123"},
                other:[{id:"1",name:"123"},{id:"2",name:"123"}，{id:"3",name:"123"}]}
            }
        ]
         */
        List<CourseTypeVo> result = new ArrayList<>();
        //遍历通过ids查询出来的CourseTypes
        for (CourseType c : CourseTypes) {
            //创建一个CourseTypeVo对象
            CourseTypeVo vo = new CourseTypeVo();
            //将自己添加到CourseTypeVo对象中
            vo.setOwnerProductType(c);
            //获取父id
            Long pid = c.getPid();
            //根据父id查询出课程类型
            List<CourseType> otherCourseTypes = baseMapper.selectListByPid(pid);
            //设置到CourseTypeVo对象中
            vo.setOtherProductTypes(otherCourseTypes);
            //将CourseTypeVo对象添加到result集合中
            result.add(vo);
        }
        //返回List<CourseTypeVo>集合
        return result;
    }
}
